home *** CD-ROM | disk | FTP | other *** search
/ Language/OS - Multiplatform Resource Library / LANGUAGE OS.iso / et / et3_0-a1.lha / et3 / src / VObject.C < prev    next >
C/C++ Source or Header  |  1992-08-26  |  20KB  |  991 lines
  1. #ifdef __GNUG__
  2. #pragma implementation
  3. #endif
  4.  
  5. #include "VObject.h"
  6.  
  7. #include "Class.h"
  8. #include "Menu.h"
  9. #include "Window.h"
  10. #include "WindowSystem.h"
  11. #include "String.h"
  12. #include "PrintManager.h"
  13. #include "ProgEnv.h"
  14. #include "OrdColl.h"
  15. #include "View.h"
  16. #include "Look.h"
  17. #include "Math.h"
  18.  
  19. Point gBorder(4, 2);
  20.  
  21. const int cAutoSize = -1;
  22.  
  23. bool testopen= FALSE;
  24.  
  25. //---- VObject -----------------------------------------------------------------
  26.  
  27. NewAbstractMetaImpl(VObject,EvtHandler, (TP(container), T(contentRect)));
  28.  
  29. VObject::VObject(Rectangle r, int id)
  30. {
  31.     SetId(id);
  32.     contentRect= r;
  33.     container= 0;
  34.     SetFlag(eVObjDefault);
  35.     if (!testopen)
  36.     SetFlag(eVObjOpen);
  37. }
  38.  
  39. VObject::VObject(int id)
  40. {
  41.     SetId(id);
  42.     contentRect= gRect0;
  43.     container= 0;
  44.     SetFlag(eVObjDefault);
  45.     if (!testopen)
  46.     SetFlag(eVObjOpen);
  47. }
  48.  
  49. void VObject::FreeAll()
  50. {
  51.     Iter next(MakeIterator());
  52.     Object *op;
  53.  
  54.     while (op= next())
  55.     op->FreeAll();
  56. }
  57.  
  58. VObject::~VObject()
  59. {
  60.     VObject *tmp= container;
  61.     container= 0;
  62.     if (tmp)
  63.     tmp->Remove(this);
  64. }
  65.  
  66. int VObject::Size()
  67. {
  68.     return 0;
  69. }
  70.  
  71. VObject *VObject::At(int)
  72. {
  73.     AbstractMethod("At");
  74.     return 0;
  75. }
  76.  
  77. VObject *VObject::SetAt(int, VObject*)
  78. {
  79.     AbstractMethod("SetAt");
  80.     return 0;
  81. }
  82.  
  83. Iterator *VObject::MakeIterator(bool)
  84. {
  85.     return new Iterator0;
  86. }
  87.  
  88. void VObject::Add(VObject*)
  89. {
  90.     AbstractMethod("Add");
  91. }
  92.  
  93. VObject *VObject::Remove(VObject*)
  94. {
  95.     AbstractMethod("Remove");
  96.     return 0;
  97. }
  98.  
  99. void VObject::RemoveFromContainer()
  100. {
  101.     if (container) {
  102.     VObject *tmp= container;
  103.     container= 0;
  104.     tmp->Remove(this);
  105.     }
  106. }
  107.  
  108. void VObject::SendDown(int id, int part, void *val)
  109. {
  110.     Iter next(MakeIterator());
  111.     VObject *vop;
  112.  
  113.     while (vop= (VObject*) next())
  114.     vop->SendDown(id, part, val);
  115. }
  116.  
  117. void VObject::CollectParts(Collection* col)
  118. {
  119.     Iter next(MakeIterator());
  120.     Object *op;
  121.  
  122.     while (op= next())
  123.     col->Add(op);
  124. }
  125.  
  126. //---- state -------------------------------------------------------------------
  127.  
  128. void VObject::Open(bool mode)
  129. {
  130.     SetFlag(eVObjOpen, mode);
  131.     if (Size() > 0) {
  132.     Iter next(MakeIterator());
  133.     VObject *vop;
  134.     
  135.     if (testopen) {
  136.         while (vop= (VObject*) next())
  137.         if (vop->IsOpen() != mode)
  138.             vop->Open(mode);
  139.     } else {
  140.         while (vop= (VObject*) next())
  141.         vop->Open(mode);
  142.     }
  143.     }
  144.     if (TestFlag(eVObjKbdFocus)) {
  145.     Window *w= GetWindow();
  146.     if (w) {
  147.         Manager *m= (Manager*)w->GetNextHandler();
  148.         if (m)  {
  149.         if (mode) {
  150.             if (m->GetFirstHandler() == 0) {
  151.             m->SetFirstHandler(this);
  152.             }
  153.         } else {
  154.             if (m->GetFirstHandler() == this) {
  155.             m->SetFirstHandler(0);
  156.             }
  157.         }
  158.         }
  159.     }
  160.     }
  161. }
  162.  
  163. bool VObject::IsOpen()
  164. {
  165.     return TestFlag(eVObjOpen);
  166. }
  167.  
  168. void VObject::Enable(bool b, bool redraw)
  169. {
  170.     if ((TestFlag(eVObjEnabled) != 0) != (b != 0)) {
  171.     SetFlag(eVObjEnabled, b);
  172.     if (redraw)
  173.         ForceRedraw();
  174.     if (Size() > 0) {
  175.         Iter next(MakeIterator());
  176.         VObject *vop;
  177.         while (vop= (VObject*) next())
  178.         vop->Enable(b, FALSE);
  179.     }
  180.     }
  181. }
  182.  
  183. void VObject::Highlight(HighlightState hst)
  184. {
  185.     bool b= (hst == On);
  186.     if (TestFlag(eVObjHighlight) != b) {
  187.     SetFlag(eVObjHighlight, b);
  188.     ForceRedraw();
  189.     }
  190. }
  191.  
  192. //---- container ---------------------------------------------------------------
  193.  
  194. void VObject::SetContainer(VObject *v)
  195. {
  196.     container= v;
  197. }
  198.  
  199. void VObject::ClearContainer(VObject *v)
  200. {
  201.     if (container && container == v)
  202.     container= 0;
  203. }
  204.  
  205. VObject *VObject::FindContainerOfClass(Class *cla)
  206. {
  207.     register VObject *vp;
  208.     
  209.     if (cla == Meta(Window))
  210.     vp= this;
  211.     else
  212.     vp= GetContainer();
  213.     
  214.     for (; vp; vp= vp->GetContainer()) {
  215.     if (vp->IsA()->isKindOf(cla))
  216.         return vp;
  217.     }
  218.     return 0;
  219. }
  220.  
  221. Point VObject::ContainerPoint(Point p)
  222. {
  223.     return p;
  224. }
  225.  
  226. Point VObject::GetPortPoint(Point p)
  227. {
  228.     p= ContainerPoint(p);
  229.     if (GetContainer())
  230.     return GetContainer()->GetPortPoint(p);
  231.     return p;
  232. }
  233.  
  234. Window *VObject::GetWindow()
  235. {
  236.     return (Window*) FindContainerOfClass(Meta(Window));
  237. }
  238.  
  239. View *VObject::GetView()
  240. {
  241.     return (View*) FindContainerOfClass(Meta(View));
  242. }
  243.  
  244. Clipper *VObject::Getclipper()
  245. {
  246.     return (Clipper*) FindContainerOfClass(Meta(Clipper));
  247. }
  248.  
  249. /*
  250. void VObject::AddToClipper(Clipper *clipper)
  251. {
  252.     VObject::SetContainer(clipper);
  253.     CalcExtent();
  254.     SetOrigin(gPoint0);
  255. }
  256. */
  257.  
  258. Rectangle VObject::GetViewedRect()
  259. {
  260.     return contentRect;
  261. }
  262.  
  263. void VObject::Focus()
  264. {
  265.     if (GetContainer())
  266.     GetContainer()->Focus();
  267. }
  268.  
  269. //---- tree walking ------------------------------------------------------------
  270.  
  271. VObject *VObject::Detect(BoolFun find, void *arg)
  272. {
  273.     if (Size() > 0) {
  274.     VObject *g1, *g2;
  275.     Iter next(MakeIterator());
  276.  
  277.     while (g1= (VObject*) next())
  278.         if (g2= g1->Detect(find, arg))
  279.         return g2;
  280.     }
  281.     if (find(this, this, arg))
  282.     return this;
  283.     return 0;
  284. }
  285.  
  286. static bool Comp1(Object*, Object *op, void *v)
  287. {
  288.     return (bool) (((VObject*)(op))->GetId() == (int)v);
  289. }
  290.  
  291. static bool Comp2(Object*, Object *op, void *v)
  292. {
  293.     VObject *vop= (VObject*) op;
  294.     Point p= *((Point*)v);
  295.     return vop->ContainsPoint(p - vop->ContainerPoint(gPoint0));
  296.     //return vop->ContainsPoint(p);
  297. }
  298.  
  299. static bool Comp3(Object*, Object *op, void *v)
  300. {
  301.     return op->IsEqual((VObject*)v);
  302. }
  303.  
  304. static bool Comp4(Object*, Object *op, void *v)
  305. {
  306.     return op == (VObject*)v;
  307. }
  308.  
  309. VObject *VObject::FindItem(int id)
  310. {
  311.     if (id != cIdNone)
  312.     return Detect(Comp1, (void*) id);
  313.     return 0;
  314. }
  315.  
  316. VObject *VObject::FindItem(Point p)
  317. {
  318.     return Detect(Comp2, &p);
  319. }
  320.  
  321. VObject *VObject::FindItem(VObject *g)
  322. {
  323.     return Detect(Comp3, g);
  324. }
  325.  
  326. VObject *VObject::FindItemPtr(VObject *g)
  327. {
  328.     return Detect(Comp4, g);
  329. }
  330.  
  331. //---- layout ------------------------------------------------------------------
  332.  
  333. Metric VObject::GetMinSize()
  334. {
  335.     if (Size() > 0) {
  336.     Metric m;
  337.     Iter next(MakeIterator());
  338.     VObject *dip;
  339.     
  340.     while (dip= (VObject*) next())
  341.         m.Merge(dip->GetMinSize());
  342.     return m;
  343.     }
  344.     return Metric(contentRect.extent);
  345. }
  346.  
  347. void VObject::CalcExtent()
  348. {
  349.     SetExtent(GetMinSize().Extent());
  350. }
  351.  
  352. int VObject::Base()
  353. {
  354.     return GetMinSize().base;
  355. }
  356.  
  357. void VObject::SetOrigin(Point origin)
  358. {
  359.     if (contentRect.origin != origin) {
  360.     contentRect.origin= origin;
  361.     if (TestFlag(eVObjLayoutCntl)) 
  362.         Control(GetId(), cPartOriginChanged, this);
  363.     Object::Send(GetId(), cPartOriginChanged, &origin);
  364.     }
  365. }
  366.  
  367. void VObject::SetExtent(Point extent)
  368. {
  369.     if (contentRect.extent != extent) {
  370.     contentRect.extent= extent;
  371.     if (TestFlag(eVObjLayoutCntl)) 
  372.         Control(GetId(), cPartExtentChanged, this);
  373.        //  Object::Send(GetId(), cPartExtentChanged, this);
  374.     Object::Send(GetId(), cPartExtentChanged, &extent);
  375.     }
  376. }
  377.  
  378. void VObject::ExtentChanged(VObject*)
  379. {
  380.     if (GetContainer())
  381.     GetContainer()->ExtentChanged(this);
  382.     //SetExtent(Max(GetMinSize().Extent(), GetExtent()));
  383. }
  384.  
  385. void VObject::SetContentRect(Rectangle r, bool redraw)
  386. {
  387.     if (!redraw && contentRect == r)
  388.     return;
  389.     if (redraw)
  390.     ForceRedraw();
  391.     if (contentRect.extent != r.extent)
  392.     SetExtent(r.extent);
  393.     SetOrigin(r.origin);
  394.     if (redraw)
  395.     ForceRedraw();
  396. }
  397.  
  398. void VObject::Align(Point at, Metric m, VObjAlign a)
  399. {
  400.     switch (a & eVObjH) {
  401.     case eVObjHLeft:
  402.     break;
  403.     case eVObjHCenter:
  404.     at.x+= (m.Width() - Width())/2;
  405.     break;
  406.     case eVObjHRight:
  407.     at.x+= m.Width() - Width();
  408.     break;
  409.     }
  410.     switch (a & eVObjV) {
  411.     case eVObjVBase:
  412.     at.y+= m.Base() - Base();
  413.     break;
  414.     case eVObjVCenter:
  415.     at.y+= (m.Height() - Height())/2;
  416.     break;
  417.     case eVObjVBottom:
  418.     at.y+= m.Height() - Height();
  419.     break;
  420.     }
  421.     SetOrigin(at);
  422. }
  423.  
  424. void VObject::Move(Point delta, bool redraw)
  425. {
  426.     if (delta == gPoint0)
  427.     return;
  428.     if (redraw)
  429.     ForceRedraw();
  430.     SetOrigin(GetOrigin()+delta);
  431.     if (redraw) {
  432.     ForceRedraw();
  433.     Changed();
  434.     }
  435. }
  436.  
  437. //---- resizing ----------------------------------------------------------------
  438.  
  439. Command *VObject::GetMover()
  440. {
  441.     VObject *v= GetView();
  442.     if (v)
  443.     return new VObjectMover(this, v->contentRect);
  444.     return new VObjectMover(this);
  445. }
  446.  
  447. Command *VObject::GetStretcher()
  448. {
  449.     VObject *v= GetView();
  450.     if (v)
  451.     return new VObjectStretcher(this, v->contentRect);
  452.     return new VObjectStretcher(this);
  453. }
  454.  
  455. bool VObject::ContainsPoint(Point p)
  456. {
  457.     return contentRect.ContainsPoint(p);
  458. }
  459.  
  460. //---- drawing -----------------------------------------------------------------
  461.  
  462. void VObject::DrawAll(Rectangle r, bool highlight)
  463. {
  464.     if (IsOpen() && r.Clip(contentRect))
  465.     DrawInner(r, (bool) (highlight || TestFlag(eVObjHighlight)));
  466. }
  467.  
  468. void VObject::DrawInner(Rectangle r, bool highlight)
  469. {
  470.     if (!GrHasColor())
  471.     Draw(r);
  472.     if (highlight && ! gPrinting)
  473.     DrawHighlight(r);
  474.     if (GrHasColor())
  475.     Draw(r);
  476. }
  477.  
  478. void VObject::Draw(Rectangle r)
  479. {
  480.     if (Size() > 0) {
  481.     Iter next(MakeIterator());
  482.     VObject *vop;
  483.     
  484.     while (vop= (VObject*) next())
  485.         vop->DrawAll(r, FALSE);
  486.     }
  487. }
  488.  
  489. void VObject::DrawHighlight(Rectangle)
  490. {
  491.     gLook->DrawHighlight(contentRect);
  492. }
  493.  
  494. void VObject::Outline2(Point p1, Point p2)
  495. {
  496.     GrStrokeRect(NormRect(p1, p2));
  497. }
  498.  
  499. void VObject::OutlineRect(Rectangle r)
  500. {
  501.     Outline2(r.NW(), r.SE());
  502. }
  503.  
  504. void VObject::Outline(Point delta)
  505. {
  506.     OutlineRect(contentRect+delta);
  507. }
  508.  
  509. void VObject::RevealRect(Rectangle r, Point minToSee)
  510. {
  511.     if (GetContainer())
  512.     GetContainer()->RevealRect(r, minToSee);
  513. }
  514.  
  515. void VObject::RevealAlign(Rectangle r, VObjAlign al)
  516. {
  517.     if (GetContainer())
  518.     GetContainer()->RevealAlign(r, al);
  519. }
  520.  
  521. void VObject::Scroll(int mode, Point scroll, bool redraw)
  522. {
  523.     if (GetContainer())
  524.     GetContainer()->Scroll(mode, scroll, redraw);
  525. }
  526.  
  527. //---- invalidation and focusing -----------------------------------------------
  528.  
  529. void VObject::InvalidateRect(Rectangle r)
  530. {
  531.     if (r.Clip(contentRect) && IsOpen() && GetContainer())
  532.     GetContainer()->InvalidateViewRect(r);
  533. }
  534.  
  535. void VObject::InvalidateViewRect(Rectangle r)
  536. {
  537.     r.origin= ContainerPoint(r.origin);
  538.     InvalidateRect(r);
  539. }
  540.  
  541. void VObject::ForceRedraw()
  542. { 
  543.     InvalidateRect(contentRect);
  544. }
  545.  
  546. void VObject::UpdateEvent()
  547. {
  548.     gWindowSystem->Update();
  549. }
  550.  
  551. GrCursor VObject::GetCursor(Point lp)
  552. {
  553.     if (GetContainer())
  554.     return GetContainer()->GetCursor(ContainerPoint(lp));
  555.     return eCrsBoldArrow;
  556. }
  557.  
  558. //---- input/output ------------------------------------------------------------
  559.  
  560. OStream& VObject::PrintOn(OStream &s)
  561. {
  562.     EvtHandler::PrintOn(s);
  563.     return s << contentRect SP;
  564. }
  565.  
  566. IStream& VObject::ReadFrom(IStream &s)
  567. {
  568.     EvtHandler::ReadFrom(s);
  569.     s >> contentRect;
  570.     container= 0;
  571.     return s;
  572. }
  573.  
  574. //---- input handling ----------------------------------------------------------
  575.  
  576. EvtHandler *VObject::GetNextHandler()
  577. {
  578.     return GetContainer();
  579. }
  580.  
  581. void VObject::DoTrackMouse(TrackPhase atp, Point)
  582. {
  583.     if (Enabled()) {
  584.     switch (atp) {
  585.     case eTrackPress:
  586.         Highlight(On);
  587.         break;
  588.     case eTrackRelease:
  589.         Control(GetId(), cPartToggle, (void*) 1);
  590.     case eTrackExit:
  591.         Highlight(Off);
  592.         break;
  593.     default:
  594.         break;
  595.     }
  596.     }
  597. }
  598.  
  599. void VObject::ReadEvent(Token &t, int timeout, bool overread)
  600. {
  601.     if (GetContainer())
  602.     GetContainer()->ReadEvent(t, timeout, overread);
  603. }
  604.  
  605. Command *VObject::Input(Point lp, Token &t, Clipper *vf)
  606. {
  607.     if (t.IsKey() || t.IsFunctionKey() || t.IsCursorKey() || ContainsPoint(lp)) {
  608.     if (Enabled()) {
  609.         if (TestFlag(eVObjKbdFocus) && t.Code == eEvtLeftButton
  610.                         && !(t.Flags & eFlgButDown)) {
  611.         GetWindow()->SetFirstHandler(this);
  612.         }
  613.         return DispatchEvents(lp, t, vf);
  614.     }
  615.     return gNoChanges;
  616.     }
  617.     return 0;     
  618. }
  619.  
  620. Command *VObject::DispatchEvents(Point lp, Token &t, Clipper *vf)
  621. {
  622.     register Command *currCmd;
  623.  
  624.     if (Size() > 0) {
  625.     Iter previous(MakeIterator(FALSE));
  626.     VObject *dip;
  627.  
  628.     while (dip= (VObject*) previous()) 
  629.         if (currCmd= dip->Input(lp, t, vf))
  630.         return currCmd;
  631.     }
  632.     
  633.     currCmd= gNoChanges;
  634.     
  635.     if (t.IsMouseButton() || t.Code == eEvtLocMove || t.Code == eEvtLocStill)
  636.     GrSetCursor(GetCursor(lp));
  637.  
  638.     switch (t.Code) {
  639.     case eEvtRightButton:
  640.     if (!(t.Flags & eFlgButDown))
  641.         currCmd= DoRightButtonDownCommand(lp, t, WindowSystem::Clicks, vf);
  642.     break;
  643.     case eEvtMiddleButton:
  644.     case eEvtLeftButton:
  645.     if (!(t.Flags & eFlgButDown)) {
  646.         if (t.Code == eEvtLeftButton) {
  647.         if (t.Flags == (eFlgShiftKey|eFlgCntlKey|eFlgMetaKey))
  648.             gProgEnv->InspectClick(this);
  649.         else
  650.             currCmd= DoLeftButtonDownCommand(lp, t, WindowSystem::Clicks);
  651.         } else
  652.         currCmd= DoMiddleButtonDownCommand(lp, t, WindowSystem::Clicks);
  653.         if (currCmd && currCmd != gNoChanges && vf)
  654.         currCmd= vf->TrackInContent(lp, t, currCmd);
  655.     }
  656.     break;
  657.     default:
  658.     if (t.IsKey())
  659.         currCmd= DoKeyCommand(t.Code, t);
  660.     else if (t.IsFunctionKey()) 
  661.         currCmd= DoFunctionKeyCommand(t.FunctionCode(), t);
  662.     else if (t.IsCursorKey())
  663.         currCmd= DoCursorKeyCommand(t.CursorDir(), t);
  664.     else if (t.Code == eEvtIdle)
  665.         currCmd= DoIdleCommand();
  666.     else
  667.         currCmd= DoOtherEventCommand(lp, t);
  668.     break;
  669.     }
  670.     return currCmd;
  671. }
  672.  
  673. Command *VObject::DoKeyCommand(int ch, Token t)
  674. {
  675.     if (GetContainer())
  676.     return GetContainer()->DoKeyCommand(ch, t);
  677.     return gNoChanges;
  678. }
  679.  
  680. Command *VObject::DoCursorKeyCommand(EvtCursorDir d, Token t)
  681. {
  682.     if (GetContainer())
  683.     return GetContainer()->DoCursorKeyCommand(d, t);
  684.     return gNoChanges;
  685. }
  686.  
  687. Command *VObject::DoFunctionKeyCommand(int pfk, Token t)
  688. {
  689.     int code= -1;
  690.     
  691.     switch (t.FunctionCode()) {
  692.     case 3:
  693.     code= cUNDO;
  694.     break;
  695.     case 5:
  696.     code= cCOPY;
  697.     break;
  698.     case 4:
  699.     code= cTOP;
  700.     break;
  701.     case 7:
  702.     code= cPASTE;
  703.     break;
  704.     case 9:
  705.     code= cCUT;
  706.     break;
  707.     case 8:
  708.     code= cFIND;
  709.     break;
  710.     case 6:
  711.     code= cOPEN;
  712.     break;
  713.     }
  714.     if (code > 0)
  715.     return DoMenuCommand(code);
  716.     if (GetContainer())
  717.     return GetContainer()->DoFunctionKeyCommand(pfk, t);
  718.     return gNoChanges;
  719. }
  720.  
  721. Command *VObject::DoMiddleButtonDownCommand(Point p, Token t, int clicks)
  722. {
  723.     if (GetContainer())
  724.     return GetContainer()->DoMiddleButtonDownCommand(ContainerPoint(p), t, clicks);
  725.     return gNoChanges;
  726. }
  727.  
  728. Command *VObject::DoLeftButtonDownCommand(Point p, Token t, int clicks)
  729. {
  730.     if (GetContainer())
  731.     return GetContainer()->DoLeftButtonDownCommand(ContainerPoint(p), t, clicks);
  732.     return gNoChanges;
  733. }
  734.  
  735. Command *VObject::DoOtherEventCommand(Point p, Token t)
  736. {
  737.     if (GetContainer())
  738.     return GetContainer()->DoOtherEventCommand(ContainerPoint(p), t);
  739.     return gNoChanges;
  740. }
  741.  
  742. Command *VObject::DoRightButtonDownCommand(Point lp, Token, int, Clipper *vf)
  743. {
  744.     if (vf) {
  745.     Menu *menu= GetMenu();
  746.     if (menu) {
  747.         int cmdno;
  748.         if ((cmdno= menu->Pulldown(lp, vf)) >= 0) {     // show menu in window
  749.         vf->Focus();
  750.         if (gFirstHandler) {
  751.             EvtHandler *old= gFirstHandler;
  752.             Command *cmd= gFirstHandler->DoMenuCommand(cmdno);
  753.             gFirstHandler= old;
  754.             gFirstHandler->PerformCommand(cmd);
  755.         } else
  756.             PerformCommand(DoMenuCommand(cmdno));
  757.         
  758.         // return DoMenuCommand(cmdno);
  759.        }
  760.     }
  761.     }
  762.     return gNoChanges;
  763. }
  764.  
  765. Command *VObject::TrackInContent(Point lp, Token t, Command *currCmd)
  766. {
  767.     if (GetContainer())
  768.     return GetContainer()->TrackInContent(ContainerPoint(lp), t, currCmd);
  769.     return currCmd;
  770. }
  771.  
  772. //---- misc --------------------------------------------------------------------
  773.  
  774. void VObject::Print()
  775. {
  776.     gPrintManager->ShowPrintDialog(this);
  777. }
  778.  
  779. //---- VObjectCommand ----------------------------------------------------------
  780.  
  781. VObjectCommand::VObjectCommand(VObject *g) : Command(cIdNone)
  782. {
  783.     vop= g;
  784.     SetFlag(eCmdNoReplFeedback);
  785. }
  786.  
  787. void VObjectCommand::Init(VObject *g, Rectangle cr, Point gr, GrCursor cd, int hy)
  788. {
  789.     vop= g;
  790.     constrainRect= cr;
  791.     grid= gr;
  792.     newcursor= cd;
  793.     firstmove= FALSE;
  794.     hysterese= hy;
  795.     oldRect= newRect= vop->ContentRect();  
  796. }
  797.  
  798. Command *VObjectCommand::TrackMouse(TrackPhase atp, Point ap, Point, Point np)
  799. {
  800.     switch (atp) {
  801.     case eTrackPress:
  802.     oldcursor= GrGetCursor();
  803.     break;
  804.  
  805.     case eTrackRelease:
  806.     GrSetCursor(oldcursor);
  807.     
  808.     if (firstmove) {
  809.         if (vop->GetView() && !TestFlag(eCmdFullScreen))     
  810.         vop->SetContentRect(oldRect, FALSE);
  811.         break;
  812.     }
  813.     return gNoChanges;
  814.  
  815.     case eTrackMove:
  816.     delta= np - ap;
  817.     if (Math::Abs(delta.x) > hysterese || Math::Abs(delta.y) > hysterese) {
  818.         firstmove= TRUE;
  819.         GrSetCursor(newcursor);
  820.     }
  821.     break;
  822.     default:
  823.     break;
  824.     }
  825.     return this;
  826. }
  827.  
  828. void VObjectCommand::TrackConstrain(Point ap, Point, Point *np)
  829. {
  830.     Rectangle r= oldRect;
  831.  
  832.     r.origin+= *np-ap;
  833.     *np+= r.AmountToTranslateWithin(constrainRect);
  834.     if (grid >= 1)
  835.     *np= (*np/grid) * grid;     // align to grid
  836. }
  837.  
  838. void VObjectCommand::TrackFeedback(Point, Point, bool on)
  839. {
  840.     if (firstmove) {
  841.     if (GrGetPenInk() != ePatXor) {
  842.         if (on)
  843.         vop->SetContentRect(newRect, TRUE);
  844.     } else
  845.         vop->Outline2(newRect.NW(), newRect.SE());
  846.     }
  847. }
  848.  
  849. void VObjectCommand::DoIt()
  850. {
  851.     vop->SetContentRect(newRect, !TestFlag(eCmdFullScreen));
  852. }
  853.  
  854. void VObjectCommand::UndoIt()
  855. {
  856.     vop->SetContentRect(oldRect, !TestFlag(eCmdFullScreen));
  857. }
  858.  
  859. //---- VObjectMover ------------------------------------------------------------
  860.  
  861. VObjectMover::VObjectMover(VObject *g) : VObjectCommand(g)
  862. {
  863.     Init(g, gRect0, gPoint1, eCrsMoveHand, 2);
  864. }
  865.  
  866. VObjectMover::VObjectMover(VObject *g, Rectangle cr) : VObjectCommand(g)
  867. {
  868.     Init(g, cr, gPoint1, eCrsMoveHand, 2);
  869. }
  870.  
  871. VObjectMover::VObjectMover(VObject *g, Rectangle cr, Point gr, GrCursor cd,
  872.                             int hy) : VObjectCommand(g)
  873. {
  874.     Init(g, cr, gr, cd, hy);
  875. }
  876.  
  877. void VObjectMover::Init(VObject *g, Rectangle cr, Point gr, GrCursor cd, int hy)
  878. {
  879.     SetName("move");
  880.     VObjectCommand::Init(g, cr, gr, cd, hy);
  881. }
  882.  
  883. Command *VObjectMover::TrackMouse(TrackPhase atp, Point ap, Point pp, Point np)
  884. {
  885.     Command *cmd= VObjectCommand::TrackMouse(atp, ap, pp, np);
  886.     switch (atp) {
  887.     case eTrackMove:
  888.     newRect= oldRect;
  889.     newRect.origin+= delta;
  890.     return this;
  891.     case eTrackRelease:
  892.     if (newRect == oldRect) {
  893.         if (vop->IsKindOf(Window))
  894.         ((Window*)vop)->Top();
  895.         cmd= gNoChanges;
  896.     }
  897.     break;
  898.     default:
  899.     break;
  900.     }
  901.     return cmd;
  902. }
  903.  
  904. //---- VObjectStretcher --------------------------------------------------------
  905.  
  906. VObjectStretcher::VObjectStretcher(VObject *g) : VObjectCommand(g)
  907. {
  908.     Init(g, gRect0, gPoint1, eCrsMoveStretch, 2, g->GetMinSize());
  909. }
  910.  
  911. VObjectStretcher::VObjectStretcher(VObject *g, Rectangle cr) : VObjectCommand(g)
  912. {
  913.     Init(g, cr, gPoint1, eCrsMoveStretch, 2, g->GetMinSize());
  914. }
  915.  
  916. VObjectStretcher::VObjectStretcher(VObject *g, Rectangle cr, Point ms) : VObjectCommand(g)
  917. {
  918.     Init(g, cr, ms, eCrsMoveStretch, 2, g->GetMinSize());
  919. }
  920.  
  921. VObjectStretcher::VObjectStretcher(VObject *g, Rectangle cr, Point ms, Point gr,
  922.                     GrCursor cd, int hy) : VObjectCommand(g)
  923. {
  924.     Init(g, cr,  gr, cd, hy, ms);
  925. }
  926.  
  927. void VObjectStretcher::Init(VObject *g, Rectangle cr, Point gr,
  928.                         GrCursor cd, int hy, Point ms)
  929. {
  930.     SetName("resize");
  931.     VObjectCommand::Init(g, cr, gr, cd, hy);
  932.     minSize= ms;
  933. }
  934.  
  935. void VObjectStretcher::TrackConstrain(Point ap, Point, Point *np)
  936. {  
  937.     switch (corner) {
  938.     case 0: case 4:
  939.     np->x= ap.x;
  940.     break;
  941.     case 2: case 6:
  942.     np->y= ap.y;
  943.     break;
  944.     }
  945. }
  946.  
  947. Command *VObjectStretcher::TrackMouse(TrackPhase atp, Point ap, Point pp, Point np)
  948. {
  949.     Point p1, p2;
  950.  
  951.     switch (atp) {
  952.     case eTrackPress:
  953.     VObjectCommand::TrackMouse(atp, ap, pp, np);
  954.     corner= oldRect.PointToCorner(ap);
  955.     break;
  956.  
  957.     case eTrackMove:
  958.     VObjectCommand::TrackMouse(atp, ap, pp, np);
  959.     p1= oldRect.NW();
  960.     p2= oldRect.SE();
  961.  
  962.     switch (corner) {
  963.     case 0: case 6: case 7:
  964.         p1+= delta;
  965.         break;
  966.     case 1:
  967.         p2.x+= delta.x;
  968.         p1.y+= delta.y;
  969.         break;
  970.     case 5:
  971.         p1.x+= delta.x;
  972.         p2.y+= delta.y;
  973.         break;
  974.     default: // case 2: case 3: case 4:
  975.         p2+= delta;
  976.         break;
  977.     }
  978.     newRect= NormRect(p1, p2);
  979.     newRect.extent= Max(newRect.extent, minSize);
  980.     break;
  981.  
  982.     case eTrackRelease:
  983.     return VObjectCommand::TrackMouse(atp, ap, pp, np);
  984.  
  985.     default:
  986.     break;
  987.     }
  988.     return this;
  989. }
  990.  
  991.